package co.gov.medellin.ssti.sub.model.dao.impl;

import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.dao.IncorrectResultSizeDataAccessException;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcDaoSupport;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;
import org.springframework.jdbc.support.GeneratedKeyHolder;

import co.gov.medellin.ssti.sub.common.excepcion.SUBException;
import co.gov.medellin.ssti.sub.model.dao.CargueDAO;
import co.gov.medellin.ssti.sub.model.dao.exception.DAOException;
import co.gov.medellin.ssti.sub.model.service.CargueService;
import co.gov.medellin.ssti.sub.model.vo.CargueVO;
import co.gov.medellin.ssti.sub.model.vo.RegNoProcesadosVO;

public class CargueDAOImpl2 extends NamedParameterJdbcDaoSupport implements
		CargueDAO {

	private static final String FIND_ARCHIVO_CARGUE = " SELECT lote.nombre nombre, lote.codigo lote, lote.archivo archivo, "
			+ " DECODE(lote.tipo_terminacion,'N','Normal','E','Error') terminacion, "
			+ " vfl_codigo.nombre valor, lote.usuario_crea usuario, lote.fecha_crea fechaCrea, "
			+ " beneficios.fcs_ben_getArea(lote.usuario_crea) dependencia, paoyer.fcs_getTotal(lote.codigo) total, "
			+ " paoyer.fcs_getCargados(lote.codigo) cargados "
			+ " FROM paoyer.TCS_LOTE_CARGUE lote, paoyer.TCS_VALOR_FLEXIBLE VFL_CODIGO "
			+ " WHERE LOTE.VFL_CODIGO = VFL_CODIGO.CODIGO ";

	private static final String TOTAL_REGISTROS = " SELECT count(codigo) total FROM paoyer.TCS_API_CARGUE WHERE LCA_CODIGO = :LCA_CODIGO ";
	private static final String TOTAL_REGISTROS_CARGADOS = " SELECT count(codigo) totalCargados FROM paoyer.TCS_API_CARGUE WHERE LCA_CODIGO = :LCA_CODIGO "
			+ " AND estado = 'C'";

	private static final String SELECT_NOMBRE_LOTE_CARGUE_BY_NOMBRE = " SELECT NOMBRE FROM paoyer.TCS_LOTE_CARGUE WHERE NOMBRE = UPPER(:NOMBRE) ";

	private static final String INSERT_LOTE_CARGUE = " INSERT INTO paoyer.TCS_LOTE_CARGUE (CODIGO,NOMBRE,VFL_CODIGO,ARCHIVO, "
			+ " USUARIO_CREA,TERMINAL_CREA,FECHA_CREA,USUARIO_MODIFICA,TERMINAL_MODIFICA,FECHA_MODIFICA) "
			+ " VALUES(paoyer.SCS_LOTE_CARGUE.NEXTVAL,UPPER(:NOMBRE), :VFL_CODIGO, UPPER(:ARCHIVO), :USUARIO_CREA, :TERMINAL_CREA, TO_DATE(:FECHA_CREA,'dd/mm/rrrr'), :USUARIO_MODIFICA, :TERMINAL_MODIFICA, TO_DATE(:FECHA_MODIFICA,'dd/mm/rrrr')) ";

	private static final String SELECT_MAX_CODIGO_LOTE_CARGUE = "SELECT MAX(codigo) codigo FROM paoyer.TCS_LOTE_CARGUE ";

	private static final String SELECT_CANTIDAD_LOTE_CARGUE = "SELECT COUNT(1) cantidad FROM paoyer.TCS_LOTE_CARGUE WHERE ('ADMINISTRADOR GENERAL' = :groupUserName OR 'SUPER USUARIO' = :groupUserName OR usuario_crea = :nameUser ) AND codigo = :codigo ";

	private static final String UPDATE_LOTE_CARGUE_ARCHIVO_EN_WEB = "UPDATE paoyer.TCS_LOTE_CARGUE SET ARCHIVO_EN_WEB = :ARCHIVO_EN_WEB WHERE codigo = :codigo ";

	private static final String DELETE_LOTE_CARGUE_BY_CODIGO = "DELETE FROM paoyer.tcs_lote_cargue WHERE codigo = :codigo ";

	private static final String DELETE_API_CARGUE_BY_LCA_CODIGO = "DELETE FROM paoyer.tcs_api_cargue where lca_codigo = :LCA_CODIGO ";

	private static final String SELECT_COUNT_CODIGO_API_CARGUE_BY_LCA_CODIGO = "SELECT count(codigo) FROM paoyer.TCS_API_CARGUE WHERE LCA_CODIGO = :LCA_CODIGO ";

	private static final String SELECT_CODIGO_API_CARGUE_BY_LCA_CODIGO = "SELECT codigo FROM paoyer.TCS_API_CARGUE WHERE lca_codigo = :LCA_CODIGO ";

	public Collection<CargueVO> findArchivoCargueByCriteria(CargueVO criteria) {
		Map<String, Object> namedParameters = new HashMap<String, Object>();

		StringBuffer query = new StringBuffer(FIND_ARCHIVO_CARGUE);

		if (criteria.getNombre() != null
				&& !criteria.getNombre().equalsIgnoreCase("")) {
			query.append(" AND UPPER(lote.nombre) LIKE UPPER(:NOMBRE) ");
			namedParameters.put("NOMBRE", "%" + criteria.getNombre() + "%");
		}
		if (criteria.getCode() != null
				&& !criteria.getCode().equalsIgnoreCase("")) {
			query.append(" AND lote.codigo = :CODIGO ");
			namedParameters.put("CODIGO", criteria.getCode());
		}
		if (criteria.getFechaFinal() != null
				&& !criteria.getFechaFinal().equals("")
				&& criteria.getFechaInicial() != null
				&& !criteria.getFechaInicial().equals("")) {
			query.append(" AND lote.fecha_crea BETWEEN TO_DATE(:FECHA_CREA_INICIAL,'dd/mm/yyyy') AND TO_DATE(:FECHA_CREA_FINAL,'dd/mm/yyyy')");
			namedParameters.put("FECHA_CREA_INICIAL",
					criteria.getFechaInicial());
			namedParameters.put("FECHA_CREA_FINAL", criteria.getFechaFinal());
		}
		query.append(" ORDER BY lote.codigo ");
		System.out.println("query:" + query);
		List<CargueVO> archivos = getNamedParameterJdbcTemplate().query(
				query.toString(), namedParameters, new RowMapper<CargueVO>() {
					public CargueVO mapRow(ResultSet rs, int rowNum)
							throws SQLException {
						CargueVO vo = new CargueVO();
						vo.setNombre(rs.getString("nombre"));
						vo.setCode(rs.getString("lote"));
						vo.setArchivo(rs.getString("archivo"));
						vo.setTipo_terminacion(rs.getString("terminacion"));
						vo.setVflcodigo(rs.getString("valor"));
						vo.setFechaCreacion(rs.getString("fechaCrea")
								.substring(0, 10));
						vo.setUsuarioCreador(rs.getString("usuario"));
						vo.setDependencia(rs.getString("dependencia"));
						vo.setTotalRegistros(rs.getString("total"));
						vo.setTotalCargados(rs.getString("cargados"));
						// String totales[] =
						// getTotalRegistros(cargue.getCode());
						// cargue.setTotalRegistros(totales[0]);
						// cargue.setTotalCargados(totales[1]);
						return vo;
					}
				});
		return archivos;
	}

	public String[] findTotalRegistrosByCodigoLote(String codeLote) {
		Map<String, Object> namedParameters = new HashMap<String, Object>();

		String retorno[] = new String[2];

		namedParameters.put("LCA_CODIGO", codeLote);
		String total;
		try {
			total = getNamedParameterJdbcTemplate().queryForObject(
					TOTAL_REGISTROS, namedParameters, String.class);
		} catch (IncorrectResultSizeDataAccessException e) {
			retorno[0] = "0";
			retorno[1] = "0";
			return retorno;
		}
		if (total != null && !total.isEmpty()) {
			retorno[0] = total;
			// reusar map
			namedParameters.clear();
			namedParameters.put("LCA_CODIGO", codeLote);
			String totalCargados;
			try {
				totalCargados = getNamedParameterJdbcTemplate()
						.queryForObject(TOTAL_REGISTROS_CARGADOS,
								namedParameters, String.class);
				retorno[1] = totalCargados;
			} catch (IncorrectResultSizeDataAccessException e) {
				retorno[1] = "0";
			}
		}
		return retorno;
	}

	// TODO: en lugar de seleccionar max(codigo) de lote_cargue, retornar el
	// valor del consecutivo luego de insertar.
	public String[] ingresarCargue(CargueVO criteria, String user,
			String terminal, String fecha) {
		Map<String, Object> namedParameters = new HashMap<String, Object>();

		CargueVO cargue = null;
		boolean existeCargue = false;
		String retorno[] = new String[2];
		retorno[0] = "false";

		namedParameters.put("NOMBRE", criteria.getNombre().trim());
		String nombre;

		try {
			nombre = getNamedParameterJdbcTemplate().queryForObject(
					SELECT_NOMBRE_LOTE_CARGUE_BY_NOMBRE, namedParameters,
					String.class);
			// TODO: para que settear el cargue?
			cargue = new CargueVO();
			cargue.setNombre(nombre);
			existeCargue = true;
		} catch (IncorrectResultSizeDataAccessException e) {
			existeCargue = false;
		}

		if (existeCargue) {
			retorno[0] = "false";
			return retorno;
		} else {
			int numRows = 0;

			namedParameters.put("NOMBRE", criteria.getNombre().trim());
			namedParameters.put("VFL_CODIGO", criteria.getVflcodigo());
			namedParameters.put("ARCHIVO", criteria.getArchivo());
			namedParameters.put("USUARIO_CREA", user);
			namedParameters.put("TERMINAL_CREA", terminal);
			namedParameters.put("FECHA_CREA", fecha);
			namedParameters.put("USUARIO_MODIFICA", user);
			namedParameters.put("TERMINAL_MODIFICA", terminal);
			namedParameters.put("FECHA_MODIFICA", fecha);

			GeneratedKeyHolder generatedKeyHolder = new GeneratedKeyHolder();
			SqlParameterSource parameterSource = new MapSqlParameterSource(
					namedParameters);

			System.out.println(INSERT_LOTE_CARGUE);
			System.out.println(namedParameters.toString());

			numRows = getNamedParameterJdbcTemplate().update(
					INSERT_LOTE_CARGUE, parameterSource, generatedKeyHolder,
					new String[] { "CODIGO" });

			/*
			 * GeneratedKeyHolder generatedKeyHolder = new GeneratedKeyHolder();
			 * SqlParameterSource parameterSource = new MapSqlParameterSource(
			 * namedParameters); getNamedParameterJdbcTemplate().update(query,
			 * parameterSource, generatedKeyHolder, new String[] { "CODIGO" });
			 * 
			 * return generatedKeyHolder.getKey().longValue();
			 */

			if (numRows > 0) {
				String code;
				try {
					// code = getNamedParameterJdbcTemplate().queryForObject(
					// SELECT_MAX_CODIGO_LOTE_CARGUE, namedParameters,
					// String.class);
					code = Long.toString(generatedKeyHolder.getKey()
							.longValue());
					retorno[0] = "true";
					retorno[1] = code;
					return retorno;
				} catch (Exception e) {
					retorno[0] = "false";
					return retorno;
				}

			} else {
				retorno[0] = "false";
				return retorno;
			}

		}
	}

	public boolean validateDelete(Long codeUser, String nameUser,
			String groupUserName, String codeLote) {
		Map<String, Object> namedParameters = new HashMap<String, Object>();

		if ((Object) codeUser == null) {
			return false;
		}
		int cantidad = 0;

		namedParameters.put("groupUserName", groupUserName);
		namedParameters.put("nameUser", nameUser);
		namedParameters.put("codigo", codeLote);

		try {
			cantidad = getNamedParameterJdbcTemplate()
					.queryForObject(SELECT_CANTIDAD_LOTE_CARGUE,
							namedParameters, Integer.class);
			if (cantidad > 0) {
				return true;
			} else {
				return false;
			}
		} catch (IncorrectResultSizeDataAccessException e) {
			return false;
		}
	}

	public int uploadFile(int codeLoteCargue, byte[] fileData)
			throws UnsupportedEncodingException {
		Map<String, Object> namedParameters = new HashMap<String, Object>();

		int moveac = 0;

		namedParameters.put("ARCHIVO_EN_WEB",
				new String(fileData, "ISO-8859-1"));
		namedParameters.put("codigo", codeLoteCargue);

		int a = getNamedParameterJdbcTemplate().update(
				UPDATE_LOTE_CARGUE_ARCHIVO_EN_WEB, namedParameters);

		moveac = moveToApiCargue(codeLoteCargue);
		if (moveac >= 0) {

			namedParameters.clear();
			namedParameters.put("LCA_CODIGO", codeLoteCargue);
			a = getNamedParameterJdbcTemplate().update(
					DELETE_API_CARGUE_BY_LCA_CODIGO, namedParameters);

			namedParameters.clear();
			namedParameters.put("codigo", codeLoteCargue);
			a = getNamedParameterJdbcTemplate().update(
					DELETE_LOTE_CARGUE_BY_CODIGO, namedParameters);
		}
		return moveac;
	}

	public boolean moveToCargarDatos(int codeLoteCargue, String tipoCargue,
			String user, String terminal, String userGroup, String userCode) {
		Map<String, Object> namedParameters = new HashMap<String, Object>();

		namedParameters.put("LCA_CODIGO", codeLoteCargue);

		try {
			List<Long> codigo = getNamedParameterJdbcTemplate().query(
					SELECT_CODIGO_API_CARGUE_BY_LCA_CODIGO, namedParameters,
					new RowMapper<Long>() {

						@Override
						public Long mapRow(ResultSet rs, int arg1)
								throws SQLException {
							Long lng = rs.getLong("CODIGO");
							return lng;
						}
					});
		} catch (IncorrectResultSizeDataAccessException e) {
			return false;
		}

		if (!tipoCargue.equalsIgnoreCase("")
				&& tipoCargue.equals(CargueService.BENEFICIARIOS)) {
			//
			SimpleJdbcCall jdbcCall = new SimpleJdbcCall(getDataSource())
					.withSchemaName("BENEFICIOS").withProcedureName(
							"PCS_CAR_BEN_PER");

			// parametros de la llamada al procedimiento almacenado
			namedParameters.clear();
			namedParameters.put("pn_codigo_lote", codeLoteCargue);
			namedParameters.put("v_usuario", user);
			namedParameters.put("v_terminal", terminal);

			SqlParameterSource in = new MapSqlParameterSource(namedParameters);
			jdbcCall.execute(in);

		} else if (!tipoCargue.equalsIgnoreCase("")
				&& tipoCargue.equals(CargueService.BENEFICIOS)) {
			SimpleJdbcCall jdbcCall = new SimpleJdbcCall(getDataSource())
					.withSchemaName("BENEFICIOS").withProcedureName(
							"PCS_CAR_BEN_OTOR");
			// parametros de la llamada al procedimiento almacenado
			namedParameters.clear();
			namedParameters.put("pn_codigo_lote", codeLoteCargue);
			namedParameters.put("v_usuario", user);
			namedParameters.put("v_terminal", terminal);
			namedParameters.put("v_usuariogrupo", userGroup);

			SqlParameterSource in = new MapSqlParameterSource(namedParameters);
			jdbcCall.execute(in);
		} else if (!tipoCargue.isEmpty()
				&& tipoCargue.equalsIgnoreCase(CargueService.BENEFICIOS_EMP)) {
			SimpleJdbcCall jdbcCall = new SimpleJdbcCall(getDataSource())
					.withSchemaName("BENEFICIOS").withProcedureName(
							"PCS_CAR_BOT_EMP");
			// parametros de la llamada al procedimiento almacenado
			namedParameters.clear();
			namedParameters.put("pn_codigo_lote", codeLoteCargue);
			namedParameters.put("v_usuario", user);
			namedParameters.put("v_terminal", terminal);
			namedParameters.put("v_usuariogrupo", userGroup);

			SqlParameterSource in = new MapSqlParameterSource(namedParameters);
			jdbcCall.execute(in);

		} else if (!tipoCargue.isEmpty()
				&& tipoCargue.equalsIgnoreCase(CargueService.EMPRESAS_EMP)) {
			SimpleJdbcCall jdbcCall = new SimpleJdbcCall(getDataSource())
					.withSchemaName("BENEFICIOS").withProcedureName(
							"PCS_CAR_EMP");
			// parametros de la llamada al procedimiento almacenado
			namedParameters.clear();
			namedParameters.put("pn_codigo_lote", codeLoteCargue);
			namedParameters.put("v_usuario", user);
			namedParameters.put("v_terminal", terminal);
			namedParameters.put("v_usuariogrupo", userGroup);

			SqlParameterSource in = new MapSqlParameterSource(namedParameters);
			jdbcCall.execute(in);

		}
		return true;
	}

	public boolean deleteFile(int codeLoteCargue) {
		Map<String, Object> namedParameters = new HashMap<String, Object>();

		// Llamada a P_BORRAR_DATOS CALL_P_BORRAR_DATOS pn_codigo_lote

		namedParameters.put("pn_codigo_lote", codeLoteCargue);
		SimpleJdbcCall jdbcCall = new SimpleJdbcCall(getDataSource())
				.withSchemaName("PAOYER").withCatalogName("PQCS_CARGUE")
				.withProcedureName("p_borrar_datos");
		SqlParameterSource in = new MapSqlParameterSource(namedParameters);
		jdbcCall.execute(in);

		// borrar de PAOYER.TCS_LOTE_CARGUE
		namedParameters.clear();
		// DELETE_LOTE_CARGUE_BY_CODIGO
		namedParameters.put("codigo", codeLoteCargue);
		getNamedParameterJdbcTemplate().update(DELETE_LOTE_CARGUE_BY_CODIGO,
				namedParameters);

		namedParameters.clear();
		namedParameters.put("LCA_CODIGO", codeLoteCargue);
		System.out.println(SELECT_CODIGO_API_CARGUE_BY_LCA_CODIGO);
		System.out.println("CODIGO: " + codeLoteCargue);
		try {
			long codigo = getNamedParameterJdbcTemplate().queryForObject(
					SELECT_CODIGO_API_CARGUE_BY_LCA_CODIGO, namedParameters,
					Long.class);
			return true;
		} catch (IncorrectResultSizeDataAccessException e) {
			// TODO: handle exception
			return false;
		}
	}

	public Collection<RegNoProcesadosVO> findRegistrosNoProcesados(String lote,
			String tipo) {
		Map<String, Object> namedParameters = new HashMap<String, Object>();

		String query = "";
		if (tipo != null && !tipo.equalsIgnoreCase("")) {
			if (tipo.equals(CargueService.BENEFICIARIOS)) {
				query = "SELECT lca_codigo, comentario,c_a1 tipo,c_a2 numero "
						+ "FROM paoyer.tcs_api_cargue api "
						+ "WHERE lca_codigo = :lca_codigo AND api.ESTADO = 'E'";
			} else if (tipo.equals(CargueService.BENEFICIOS)) {
				query = "SELECT lca_codigo, comentario,c_a3 tipo,c_a4 numero "
						+ "FROM paoyer.tcs_api_cargue api "
						+ "WHERE lca_codigo = :lca_codigo AND api.ESTADO = 'E'";
			} else if (tipo.equalsIgnoreCase(CargueService.BENEFICIOS_EMP)) {
				query = "SELECT lca_codigo, comentario,c_a3 tipo,c_a4 numero "
						+ " FROM paoyer.tcs_api_cargue api "
						+ " WHERE lca_codigo = :lca_codigo AND api.ESTADO = 'E'";
			} else if (tipo.equalsIgnoreCase(CargueService.EMPRESAS_EMP)) {
				query = "SELECT lca_codigo, comentario,c_a3 tipo,c_a4 numero "
						+ " FROM paoyer.tcs_api_cargue api "
						+ " WHERE lca_codigo = :lca_codigo AND api.ESTADO = 'E'";
			}
		}

		namedParameters.put("lca_codigo", lote);

		List<RegNoProcesadosVO> regs = getNamedParameterJdbcTemplate().query(
				query, namedParameters, new RowMapper<RegNoProcesadosVO>() {
					public RegNoProcesadosVO mapRow(ResultSet rs, int rowNum)
							throws SQLException {
						RegNoProcesadosVO vo = new RegNoProcesadosVO();
						vo.setCode(rs.getString("lca_codigo"));
						vo.setComentario(rs.getString("comentario"));
						vo.setTipoDocumento(rs.getString("tipo"));
						vo.setNumeroDocumento(rs.getString("numero"));
						return vo;
					}
				});
		return regs;
	}

	public int deleteCargue(String codeLote) {
		Map<String, Object> namedParameters = new HashMap<String, Object>();

		String query = "SELECT COUNT(1) CANTIDAD "
				+ " FROM TCS_BEN_BENEFICIO_OTORGADO WHERE CAMPO_N1 = :CAMPO_N1 ";
		namedParameters.put("CAMPO_N1", codeLote);

		int cantidad = 0;

		try {
			cantidad = getNamedParameterJdbcTemplate().queryForObject(query,
					namedParameters, Integer.class);
		} catch (IncorrectResultSizeDataAccessException e) {

		}

		if (cantidad > 0) {
			SimpleJdbcCall jdbcCall = new SimpleJdbcCall(getDataSource())
					.withSchemaName("BENEFICIOS").withProcedureName(
							"PCS_BEN_DELETE_BOT");
			// parametros de la llamada al procedimiento almacenado
			namedParameters.clear();
			namedParameters.put("codigoLote", codeLote);

			SqlParameterSource in = new MapSqlParameterSource(namedParameters);
			Map<String, Object> simpleJdbcCallResult = jdbcCall.execute(in);
			return (Integer) simpleJdbcCallResult.get("vn_updated");
		}
		return 0;
	}

	@Override
	public int deleteCargueEmpresa(String codeLote) {
		Map<String, Object> namedParameters = new HashMap<String, Object>();

		String query = "SELECT COUNT(1) CANTIDAD "
				+ " FROM TCS_BOT_EMPRESA WHERE CAMPO_N1 = :CAMPO_N1 ";
		namedParameters.put("CAMPO_N1", codeLote);

		int cantidad = 0;

		try {
			cantidad = getNamedParameterJdbcTemplate().queryForObject(query,
					namedParameters, Integer.class);
		} catch (IncorrectResultSizeDataAccessException e) {

		}

		if (cantidad > 0) {
			SimpleJdbcCall jdbcCall = new SimpleJdbcCall(getDataSource())
					.withSchemaName("BENEFICIOS").withProcedureName(
							"PCS_DELETE_CARGUE_BOT_EMP");
			// parametros de la llamada al procedimiento almacenado
			namedParameters.clear();
			namedParameters.put("codigoLote", codeLote);

			SqlParameterSource in = new MapSqlParameterSource(namedParameters);
			BigDecimal bigDecimal = jdbcCall
					.executeObject(BigDecimal.class, in);
			if (bigDecimal != null) {
				return bigDecimal.intValue();
			}
		}
		return 0;
	}

	private int moveToApiCargue(int codeLoteCargue) throws DAOException {
		Map<String, Object> namedParameters = new HashMap<String, Object>();

		namedParameters.put("LCA_CODIGO", codeLoteCargue);
		int numRows = getNamedParameterJdbcTemplate().update(
				DELETE_API_CARGUE_BY_LCA_CODIGO, namedParameters);

		try {
			namedParameters.clear();
			namedParameters.put("pn_codigo_lote", codeLoteCargue);
			namedParameters.put("pv_separador", ";");
			SimpleJdbcCall jdbcCall = new SimpleJdbcCall(getDataSource())
					.withSchemaName("PAOYER").withCatalogName("PQCS_CARGUE")
					.withProcedureName("p_pobla_datos_de_clob");
			SqlParameterSource in = new MapSqlParameterSource(namedParameters);
			Map<String, Object> map = jdbcCall.execute(in);
			System.out.println(map);
			;
		} catch (Exception e) {
			if (e.getMessage()
					.startsWith(
							"ORA-20500: Pqcs_Cargue.P_POBLA_DATOS_DE_CLOB-Inserta la linea en TCS_API_CARGUE")) {
				return getBadRecord(codeLoteCargue);
			} else {
				SUBException.logDebugError("Error moveToApiCargue: ", e);
			}
			return 0;
		}

		namedParameters.put("LCA_CODIGO", codeLoteCargue);
		try {
			System.out.println(SELECT_CODIGO_API_CARGUE_BY_LCA_CODIGO);
			System.out.println(namedParameters.toString());
			List<Long> codigo = getNamedParameterJdbcTemplate().query(
					SELECT_CODIGO_API_CARGUE_BY_LCA_CODIGO, namedParameters,
					new RowMapper<Long>() {

						@Override
						public Long mapRow(ResultSet rs, int arg1)
								throws SQLException {
							Long lng = rs.getLong("CODIGO");
							return lng;
						}
					});

			if (codigo != null && !codigo.isEmpty()) {
				return -1;
			}
		} catch (IncorrectResultSizeDataAccessException e) {
			System.err.println(e.getMessage());
		}
		return 0;
	}

	private int getBadRecord(int codeLote) {
		Map<String, Object> namedParameters = new HashMap<String, Object>();

		try {
			namedParameters.put("LCA_CODIGO", codeLote);
			int ret = getNamedParameterJdbcTemplate().queryForObject(
					SELECT_COUNT_CODIGO_API_CARGUE_BY_LCA_CODIGO,
					namedParameters, Integer.class);
			return ret + 1;
		} catch (IncorrectResultSizeDataAccessException e) {
			return 0;
		}
	}

}
